package cn.ssm.ssm_admin;

import java.util.HashMap;

/**
 * Interpreter模式演示类
 */
public class InterpreterDemo {
    /**
     * 主函数入口
     * 使用Interpreter模式解释执行一个数学表达式
     * @param args 命令行参数
     */
    public static void main(String[] args) {
        // 准备上下文环境
        Context context = new Context();
        context.setVariable("x", 5);
        context.setVariable("y", 3);
        context.setVariable("z", 2);

        // 构建复杂表达式：(x * (y + z)) + 10
        Expression expression = new AddExpression(
                new MultiplyExpression(
                        new VariableExpression("x"),
                        new AddExpression(
                                new VariableExpression("y"),
                                new VariableExpression("z")
                        )
                ),
                new NumberExpression(10)
        );


        // 解释执行并输出结果
        int result = expression.interpret(context);
        System.out.println("计算结果：" + result);  // 输出：5*(3+2)+10=35
    }
}

// 抽象表达式接口
interface Expression {
    /**
     * 解释表达式
     * @param context 上下文环境，包含变量值
     * @return 表达式的计算结果
     */
    int interpret(Context context);
}

// 终结符表达式：数字常量
class NumberExpression implements Expression {
    private final int value;

    /**
     * 构造一个数字表达式
     * @param value 数字值
     */
    public NumberExpression(int value) {
        this.value = value;
    }

    @Override
    public int interpret(Context context) {
        return value;  // 直接返回固定值
    }
}

// 终结符表达式：变量引用
class VariableExpression implements Expression {
    private final String variableName;

    /**
     * 构造一个变量表达式
     * @param name 变量名
     */
    public VariableExpression(String name) {
        this.variableName = name;
    }

    @Override
    public int interpret(Context context) {
        return context.getVariable(variableName);  // 从上下文获取变量值
    }
}

// 非终结符表达式：加法运算
class AddExpression implements Expression {
    private final Expression left;
    private final Expression right;

    /**
     * 构造一个加法表达式
     * @param left 左操作数
     * @param right 右操作数
     */
    public AddExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Context context) {
        // 递归计算左右子树的值
        return left.interpret(context) + right.interpret(context);

    }
}

// 非终结符表达式：乘法运算（扩展示例）
class MultiplyExpression implements Expression {
    private final Expression left;
    private final Expression right;

    /**
     * 构造一个乘法表达式
     * @param left 左操作数
     * @param right 右操作数
     */
    public MultiplyExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret(Context context) {
        System.out.println(left.interpret(context));
        return left.interpret(context) * right.interpret(context);
    }
}

// 上下文环境（存储变量值）
class Context {
    private final HashMap<String, Integer> variables = new HashMap<>();

    /**
     * 设置变量值
     * @param name 变量名
     * @param value 变量值
     */
    public void setVariable(String name, int value) {
        variables.put(name, value);
    }

    /**
     * 获取变量值
     * @param name 变量名
     * @return 变量值
     * @throws RuntimeException 如果变量未定义
     */
    public int getVariable(String name) {
        if (!variables.containsKey(name)) {
            throw new RuntimeException("Undefined variable: " + name);
        }
        return variables.get(name);
    }
}
